package com.xszx.utils;

import java.util.Map;
import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 增强版仓库编号生成器（支持存储方式识别）
 */
public class WarehouseCodeGenerator{

    // 仓库类型前缀映射
    private static final Map<String, String> TYPE_PREFIX = new HashMap<>();
    static {
        TYPE_PREFIX.put("常温仓库", "NT");  // Normal Temperature
        TYPE_PREFIX.put("冷藏仓库", "CL");  // Cold Storage
        TYPE_PREFIX.put("冷冻仓库", "FR");  // Frozen
        TYPE_PREFIX.put("化学仓库", "HAZ"); // Hazardous
        TYPE_PREFIX.put("恒温仓库", "CT");  // Constant Temperature
    }

    // 区域存储类型后缀映射
    private static final Map<String, String> STORAGE_TYPE_SUFFIX = new HashMap<>();
    static {
        STORAGE_TYPE_SUFFIX.put("平铺", "FL");  // FLat storage
        STORAGE_TYPE_SUFFIX.put("货架", "SH");  // SHelf
        STORAGE_TYPE_SUFFIX.put("钩子", "HK");  // HooK
    }

    // 仓库类型计数器（确保同类型仓库编号不重复）
    private static final Map<String, AtomicInteger> warehouseTypeCounters = new ConcurrentHashMap<>();

    // 区域编号计数器（按仓库编号隔离，确保同仓库下区域编号不重复）
    private static final Map<String, AtomicInteger> areaCounters = new ConcurrentHashMap<>();

    /**
     * 生成仓库编号（确保同类型仓库后四位不重复）
     * @param warehouseType 仓库类型
     * @return 格式化的仓库编号，例如：CL-WH-1001
     */
    public static synchronized String generateWarehouseCode(String warehouseType) {
        String prefix = validateAndGetPrefix(warehouseType, TYPE_PREFIX);

        // 初始化该类型的计数器（如果不存在）
        warehouseTypeCounters.putIfAbsent(prefix, new AtomicInteger(1000));

        // 获取并递增序列号
        int seq = warehouseTypeCounters.get(prefix).incrementAndGet();

        return String.format("%s-WH-%04d", prefix, seq);
    }

    /**
     * 生成区域编号（确保同仓库下区域编号不重复）
     * @param warehouseCode 所属仓库编号
     * @param storageType 存储方式
     * @return 示例：CL-WH-1001-SH01
     */
    public static synchronized String generateAreaCode(
            String warehouseCode,
            String storageType) {

        // 验证仓库编号格式
        if (!warehouseCode.matches(".+-WH-\\d{4}")) {
            throw new IllegalArgumentException("无效的仓库编号格式");
        }

        String storageSuffix = validateAndGetPrefix(storageType, STORAGE_TYPE_SUFFIX);

        // 使用仓库编号作为key的一部分，确保同仓库下区域编号不重复
        String counterKey = warehouseCode + "-" + storageSuffix;

        // 初始化该仓库的区域计数器（如果不存在）
        areaCounters.putIfAbsent(counterKey, new AtomicInteger(0));

        // 获取并递增序列号
        int seq = areaCounters.get(counterKey).incrementAndGet();

        return String.format("%s-%s%02d", warehouseCode, storageSuffix, seq);
    }

    /**
     * 从区域编号解析存储方式
     */
    public static String parseStorageType(String areaCode) {
        for (Map.Entry<String, String> entry : STORAGE_TYPE_SUFFIX.entrySet()) {
            if (areaCode.contains("-" + entry.getValue())) {
                return entry.getKey();
            }
        }
        return "未知存储方式";
    }

    private static String validateAndGetPrefix(String type, Map<String, String> prefixMap) {
        String prefix = prefixMap.get(type);
        if (prefix == null) {
            throw new IllegalArgumentException("不支持的类型: " + type +
                    "，有效类型: " + prefixMap.keySet());
        }
        return prefix;
    }

    // 测试代码
    public static void main(String[] args) {
        // 测试同类型仓库编号不重复
        String coldStorage1 = generateWarehouseCode("冷藏仓库");
        String coldStorage2 = generateWarehouseCode("冷藏仓库");
        System.out.println("冷藏仓库1: " + coldStorage1); // CL-WH-1001
        System.out.println("冷藏仓库2: " + coldStorage2); // CL-WH-1002

        // 测试同仓库下区域编号不重复
        String shelfArea1 = generateAreaCode(coldStorage1, "货架");
        String shelfArea2 = generateAreaCode(coldStorage1, "货架");
        System.out.println("货架区域1: " + shelfArea1); // CL-WH-1001-SH01
        System.out.println("货架区域2: " + shelfArea2); // CL-WH-1001-SH02

        // 测试不同仓库的区域编号
        String shelfArea3 = generateAreaCode(coldStorage2, "货架");
        System.out.println("货架区域3: " + shelfArea3); // CL-WH-1002-SH01
    }
}